import bpy

import 物体.物体管理.物体数据 as 网格数据

from 节点.全局控制.Node.物体数据生成 import bl_集合物体处理
from 节点.全局控制.Node.节点和插座基类 import bl_节点基类
from 节点.Core import bl_UI配色
from 节点.Core import bl_Mesh

import engine.initLIB.load_dll as engineLib
import ctypes


engineLib.flexCAPI.f_创建物体节点.restype = ctypes.c_bool
engineLib.flexCAPI.f_创建BL物体节点.restype = ctypes.c_bool
engineLib.flexCAPI.f_创建设置物体ID节点.restype = ctypes.c_bool












class C_Node_创建物体(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_创建物体'
	bl_label = '创建物体'
	
	def init(self, context):
		super(C_Node_创建物体, self).f_init(context)
		self.inputs.new('C_Socket_文本', name='名称')
		self.inputs.new('C_Socket_I32', name='数量')
		self.outputs.new('C_Socket_物体_Array1D', name='物体')
		
		self.f_toCPP(self.id_data);

	def f_toCPP(self, tree):
		是否更新 = engineLib.flexCAPI.f_创建物体节点(ctypes.c_wchar_p(tree.name), ctypes.c_wchar_p(self.name), self.f_getPyObject(tree));
		if 是否更新 :
			self.use_custom_color = True
			self.color = bl_UI配色.g_物体类节点颜色

			self.inputs['名称'].f_update()
			self.inputs['数量'].f_update()



class C_NODE_MENU_创建物体(bpy.types.Operator):
	bl_idname = 'node.global_node_create_object'
	bl_label = '创建物体'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_创建物体', use_transform=True)
		return {'FINISHED'}


















class C_Node_创建BL物体(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_创建BL物体'
	bl_label = '创建BL物体'
	
	def init(self, context):
		super(C_Node_创建BL物体, self).f_init(context)
		self.inputs.new('C_Socket_文本', name='名称')
		self.inputs.new('C_Socket_物体_Array1D', name='内部物体')
		self.inputs.new('C_Socket_物体数据_Array1D', name='数据')
		self.outputs.new('C_Socket_物体_Array1D', name='物体')
		self.f_toCPP(self.id_data);

	def f_toCPP(self, tree):
		是否更新 = engineLib.flexCAPI.f_创建BL物体节点(ctypes.c_wchar_p(tree.name), ctypes.c_wchar_p(self.name), self.f_getPyObject(tree));
		if 是否更新 :
			self.use_custom_color = True
			self.color = bl_UI配色.g_物体类节点颜色
			self.inputs['名称'].f_update()

	def f_update(self):
		内部物体 = self.inputs['内部物体'].f_getData()
		print('f_update   C_Node_创建BL物体 = ', 内部物体)
		for obj in 内部物体:
			print('C_Node_创建BL物体 = ', obj)



class C_NODE_MENU_创建BL物体(bpy.types.Operator):
	bl_idname = 'node.global_node_create_blender_object'
	bl_label = '创建BL物体'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_创建BL物体', use_transform=True)
		return {'FINISHED'}












def f_update_创建网格参数(self, context):
	if context :
		self.id_data.f_节点数据更新_更新树([self])
		


class C_Node_从网格创建物体(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_从网格创建物体'
	bl_label = '从网格创建物体'
	
	m_名称 = bpy.props.StringProperty(update=f_update_创建网格参数)
	m_平滑 = bpy.props.BoolProperty(update=f_update_创建网格参数)
	m_坐标系转换 = bpy.props.BoolProperty(default=True, update=f_update_创建网格参数)
	def init(self, context):
		super(C_Node_从网格创建物体, self).f_init(context)
		self.inputs.new('C_Socket_集合', name='集合')
		self.inputs.new('C_Socket_网格_Array1D', name='网格群')
		self.inputs.new('C_Socket_矩阵4X4_Array1D', name='矩阵')
		
		self.outputs.new('C_Socket_物体_Array1D', name='新物体')

		self.f_toCPP(self.id_data)

	def draw_buttons(self, context, layout):
		layout.prop(self, "m_名称")
		layout.prop(self, "m_平滑")
		layout.prop(self, "m_坐标系转换")
		
	def f_toCPP(self, tree):
		是否更新 = engineLib.flexCAPI.f_创建从网格创建物体(ctypes.c_wchar_p(tree.name), ctypes.c_wchar_p(self.name), self.f_getPyObject(tree));
		if 是否更新 :
			self.use_custom_color = True
			self.color = bl_UI配色.g_网格类节点颜色

	def f_update(self):
		集合 = self.inputs['集合'].f_getData()

		if 集合 == None :
			name = '__物体拷贝集合_' + self.name
			集合 = bl_集合物体处理.f_get集合(name)

		已有物体数量 = len(集合.objects)
		
		
		objs = []
		
		#if engineLib.flexCAPI.f_node_是否即时更新节点() :
		offset = 0

		meshs = engineLib.flexCAPI.f_取节点数据(ctypes.c_wchar_p(self.id_data.name), ctypes.c_wchar_p(self.name));
		#print('已有物体数量 = ', 已有物体数量, meshs)
		网格数量 = len(meshs[0])
		矩阵数量 = len(meshs[1])
		
		for mesh in meshs[0]:
			me = None
			if offset >= 已有物体数量:
				#创建新物体
				name = "新物体拷贝"+str(offset)
				me = bpy.data.meshes.new(name)
				obj = bpy.data.objects.new(name = name, object_data=me)
				集合.objects.link(obj)
			else:
				obj = 集合.objects[offset]
				me = obj.data
				
			objs.append((list(obj.name), obj.m_物体ID, obj))
			bl_Mesh.f_构建bl网格(me, mesh)

			if 矩阵数量 >= 网格数量:
				mat = meshs[1][offset]
			else:
				mat = meshs[1][0]
			obj.matrix_world = mat

			#if self.m_坐标系转换:
			#	物体数据.f_右手坐标系转左手坐标系(me)
			offset += 1
			
		if offset < 已有物体数量:
			for obj in 集合.objects[offset:]:
				集合.objects.unlink(obj)
					
		'''else:
		for obj in 集合.objects:
			objs.append((list(obj.name), obj.m_物体ID, obj))
		print('objs = ', objs)'''
		self.outputs['新物体'].f_setData(objs)


	def f_release(self):
		集合 = self.inputs['集合'].f_getData()
		if 集合 :
			bpy.data.collections.remove(集合)

		super(C_Node_从网格创建物体, self).free()


class C_NODE_MENU_从网格创建物体(bpy.types.Operator):
	bl_idname = 'node.from_meshs_create_objects'
	bl_label = '从网格创建物体'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_从网格创建物体', use_transform=True)
		return {'FINISHED'}

















class C_Node_设置物体ID(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_设置物体ID'
	bl_label = '设置物体ID'
	
	def init(self, context):
		super(C_Node_设置物体ID, self).f_init(context)
		self.inputs.new('C_Socket_物体_Array1D', name='物体')
		self.inputs.new('C_Socket_I32_Array1D', name='偏移')
		self.outputs.new('C_Socket_I32_Array1D', name='ID')
		self.f_toCPP(self.id_data);
		
	def f_toCPP(self, tree):
		是否更新 = engineLib.flexCAPI.f_创建设置物体ID节点(ctypes.c_wchar_p(tree.name), ctypes.c_wchar_p(self.name), self.f_getPyObject(tree));
		if 是否更新 :
			self.use_custom_color = True
			self.color = bl_UI配色.g_物体类节点颜色
			self.inputs['偏移'].f_update()
			

class C_NODE_MENU_设置物体ID(bpy.types.Operator):
	bl_idname = 'node.global_node_set_object_id'
	bl_label = '设置物体ID'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_设置物体ID', use_transform=True)
		return {'FINISHED'}








classes = (
	C_Node_创建物体,
	C_NODE_MENU_创建物体,
	
	C_Node_创建BL物体,
	C_NODE_MENU_创建BL物体,

	C_Node_从网格创建物体,
	C_NODE_MENU_从网格创建物体,

	C_Node_设置物体ID,
	C_NODE_MENU_设置物体ID,

)

def register():
	for c in classes:
		bpy.utils.register_class(c)
		
def unregister():
	for c in classes:
		bpy.utils.unregister_class(c)



